Developer CD Series 1996 May: Tool Chest

home *** CD-ROM | disk | FTP | other *** search

/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Tool Chest / Development Tools & Languages / Dylan Related / J-Dylan info / DIRMJ - Common Ground / Chap.8-15 (.txt) < prev next >

Wrap

Common Ground | 1994-12-13 | 560.9 KB | 2,973 lines | [CGDC/CGVM]

Chap.8-15 CGDCCGVM wqCGDC Palatino (Controlling Dynamism) Dylan Courier abstract concrete) primary) free) seal generic define sealed method sealed slot seal generic adjectives &(Declaring characteristics of classes) sealed primary abstract concrete adjectives) sealed sealed library <class> <class> primary free) instance allocated) Palatino ((Declaring sealing of generic functions) Courier sealed library add-method remove-method <generic-function> seal generic (The seal generic form) seal generic seal generic function , ... function types <type> types )0 function seal generic not an explicitly known method) (disjoint disjoint (Defining New Classes) (Slot Uniqueness) Palatino i, j, k Courier seal generic disjoint seal generic Abbreviations for seal generic) define sealed method define sealed method seal generic define class sealed <object> define class sealed seal generic Palatino (Collections) Dylan protocol) Helvetica <collection> ABSTRACT INSTANTIABLE SEALED COLLECTION CLASSES <mutable-collection> !<mutable-explicit-key-collection> <sequence> <explicit-key-collection> <mutable-sequence> <array> <table> <vector> <string> <deque> <range> <stretchy-vector> <simple-object-vector> <unicode-string> <byte-string> <list> <empty-list> <pair> <stretchy-collection> (Functions for Collections) Dylan Courier collection Symbol {integer [Generic Function] collection Dylan Palatino iterating through) Courier class-for-copy mutable-collection Symbol class [G.F. Method] class-for-copy mutable) class-for- <object> class-for- <mutable-sequence> explicit-key-collection class )# -for-copy )$ <mutable- explicit-key-collection> empty? collection boolean [Generic Function] collection procedure collection #rest more-collections [Function] false procedure collections % do (method (a, b) print (a + b) end, #(100, 100, 200, 200), #(1, 2, 3, 4)) procedure collection #rest more-collections [Function] new-collection collection procedure collection class-for-copy collections size: map (\+, #(100, 100, 200, 200), #(1, 2, 3, 4)) #(101, 102, 203, 204) Courier map-as Palatino class procedure collection #rest more-collections [Function] Symbol new-collection map-as collection procedure class class <mutable- collection> size: collections size: map-as (<vector>, \+, 0 #(100, 100, 200, 200), #(1, 2, 3, 4)) #(101, 102, 203, 204) map-into mutable-collection procedure [Function] collection #rest more-collections mutable-collection map-into mutable-collection collection more-collections )c procedure mutable-collection mutable-collection <stretchy-collection> (alignment requirement mutable-collection D procedure )` procedure mutable-collection element-setter mutable-collection mutable-collection map-into <stretchy- collection> key-test mutable-collection collection more-collections . define variable x = list (100, 100, 200, 200) map-into (x, \+, #(1, 2, 3, 4)) #(101, 102, 203, 204) #(101, 102, 203, 204) procedure collection #rest more-collections [Function] value collection more-collections procedure Courier Palatino procedure procedur procedure ( any? (\>, #(1, 2, 3 ,4), #(5, 4, 3, 2)) any? (even?, #(1, 3, 5, 7)) every? procedure collection #rest more-collections [Function] Symbol boolean every? every? procedure * every? (\>, #(1, 2, 3, 4), #(5, 4, 3, 2)) every? (odd?, #(1, 3, 5, 7)) reduce )*& procedure initial-value collection value [Generic Function] procedure collection collection reduce initial-value )T procedure initial-value collection collection procedure collection collection collection define variable high-score = 10 high-score . reduce (max, high-score, #(3, 1, 4, 1, 5, 9)) / reduce (max, high-score, #(3, 12, 9, 8, 8, 6)) reduce1 procedure collection value [Generic Function] reduce1 reduce collection collection reduce (unstable) collection collection reduce1 (\+, #(1, 2, 3, 4, 5)) member? value collection test boolean [Generic Function] Courier member? Palatino collection value value collection A define constant flavors = #(#"vanilla", #"pistachio", #"ginger") flavors member? (#"vanilla", flavors) member? (#"banana", flavors) find-key collection procedure skip failure Symbol key [Generic Function] )< procedure (element( collection procedure failure element collection )0 procedure skip failure flavors 0&#(#"vanilla", #"pistachio", #"ginger") find-key (flavors, has-nuts?) flavors[1] #"pistachio" replace-elements! mutable-collection pred icate [Generic Function] new-value-fn count mutable-collection )< predicate mutable-collection value-fn count count 0 define variable numbers = list (10, 13, 16, 19) numbers * replace-elements! (numbers, odd?, double) #(10, 26, 16, 38) fill! mutable-collection value start end [Generic Function] fill! mutable-collection element mutable- collection ,key value mutable-collection Palatino (mutable sequence) start start Courier 0 define variable numbers = list (10, 13, 16, 19) numbers fill! (numbers, 3, start: 2) #(10, 13, 3, 3) key-test collecti test-function [Generic Function] iteration protocol ) element key-test element (Functions for Sequences) Dylan add-new remove choose choose-by intersection union remove- duplicates copy-sequence concatenate reverse primary) class- for-copy range ass-for-copy <list> copy-sequence size-setter n stretchy-sequence Symbol [Generic Function] stretchy-sequence size) stretchy-sequence stretchy-sequence stretchy-sequence stretchy-sequence stretchy-sequence size: fill: stretchy-sequence size-setter stretchy-sequence Dylan Courier Palatino sequence new-element Symbol new-sequence [Generic Function] new-element sequence sequence sequence sequence % define variable numbers = #(3, 4, 5) numbers add (numbers, 1) #(1, 3, 4, 5) numbers #(3, 4, 5) ) sequence1 new-element sequence2 [Generic Function] new-element )< sequence1 sequence1 , sequence2 sequence1 sequence1 sequence2 sequence1 ) define variable numbers = list (3, 4, 5) numbers add! (numbers, 1) #(1, 3, 4, 5) add-new sequence new-element test new-sequence [Generic Function] new-element sequence add-new new-element sequence sequence sequence sequence new-element add-new (#(3, 4, 5), 1) #(1, 3, 4, 5) add-new (#(3, 4, 5), 4) #(3, 4, 5) add-new! sequence new-element test new-sequence [Generic Function] new-element sequence add-new! new-element sequence sequence sequence sequence new-element add-new! (list (3, 4, 5), 1) Courier #(1, 3, 4, 5) add-new! (list (3, 4, 5), 4) #(3, 4, 5) remove Palatino ence value test count Symbol new-sequence [Generic Function] remove sequence value value count value count value sequence sequence sequence value remove (#(3, 1, 4, 1, 5, 9), 1) #(3, 4, 5, 9) remove! sequence value test count new-sequence [Generic Function] remove! sequence value value count value count value sequence sequence sequence value % remove! (list (3, 1, 4, 1, 5, 9), 1) #(3, 4, 5, 9) choose predicate sequence new-sequence [Generic Function] choose sequence )0 predicate $ choose (even?, #(3, 1, 4, 1, 5, 9)) choose-by )?+ predicate test-sequence value-sequence [Generic Function] new-sequence choose-by value-sequence test-sequence )` predicate # choose-by (even?, range (from: 1), 0< #("a", "b", "c", "d", "e", "f", "g", "h", "i")) #("b", "d", "f", "h") intersection sequence1 sequence2 test [Generic Function] new-sequence Courier intersection Palatino sequence1 )0 sequence2 )H sequence2 )$ sequence1 sequence2 4 intersection (#("john", "paul", "george", "ringo"), 0< #("richard", "george", "edward", "charles"), test: \=) #("george") union sequence1 sequence2 test Symbol new-sequence [Generic Function] union sequence1 sequence2 sequence1 )` sequence2 6 union (#("butter", "flour", "sugar", "salt", "eggs"), 0< #("eggs", "butter", "mushrooms", "onions", "salt"), test: \=) D#("salt", "butter", "flour", "sugar", "eggs", "mushrooms", "onions") remove-duplicates sequence test new-sequence [Generic Function] sequence sequence sequence sequence . remove-duplicates (#("spam", "eggs", "spam", 02 "sausage", "spam", "spam"), test: \=) #("spam", "eggs", "sausage") remove-duplicates! sequence test new-sequence [Generic Function] sequence sequence sequence sequence sequence / remove-duplicates! (#("spam", "eggs", "spam", Courier 2 "sausage", "spam", "spam"), test: \=) #("spam", "eggs", "sausage") copy-sequence Palatino source start end Symbol new-se quence [Generic Function] copy-sequence source start source @ define constant hamlet = #("to", "be", "or", "not", "to", "be") hamlet ! hamlet == copy-sequence (hamlet) ) copy-sequence (hamlet, start: 2, end: 4) #("or", "not") concatenate-as class sequence1 #rest more-sequences [Function] new-sequence concatenate-as class class <mutable-sequence> size: size: > concatenate-as (<string>, #('n', 'o', 'n'), #('f', 'a', 't')) "nonfat" concatenate sequence1 #rest sequences new-sequence Function] concatenate sequence concatenate class-for- class-for-copy <mutable-collection> size: size: concatenate ("low-", "calorie") "low-calorie" replace-subsequence! sequence insert-sequence #key )! start end [Generic Function] result-sequence insert-sequence )T sequence start start Courier Palatino sequence result-sequence sequence sequence sequence result-sequence insert-sequence result-sequence 04? define variable x = list ("a", "b", "c", "d", "e") 0=? abcde := replace-subsequence! (x, #("x", "y", "z"), end: 1) $#("x", "y", "z", "b", "c", "d", "e") ?? abcde := replace-subsequence! (x, #("x", "y", "z"), start: 4) $#("x", "y", "z", "b", "x", "y", "z") 6? abcde := replace-subsequence! (x, #("a", "b", "c"), 9 start: 2, end: 4) )#("x", "y", "a", "b", "c", "x", "y", "z") reverse sequence Symbol new-sequence [Generic Function] reverse sequence sequence , define constant x = #("bim", "bam", "boom") reverse(x) #("boom", "bam", "bim") #("bim", "bam", "boom") reverse! sequence1 sequence2 [Generic Function] reverse! sequence )< sequence sequence sequence test stable new-sequence [Generic Function] sort sequence stable test(x, y) test(y, x) . define variable numbers = #(3, 1, 4, 1, 5, 9) numbers sort (numbers) #(1, 1, 3, 4, 5, 9) numbers #(3, 1, 4, 1, 5, 9) Courier sort! Palatino sequence1 test stable Symbol sequence2 [Generic Function] sequence sequence first sequence default value [Function] second sequence default value [Function] third sequence default value [Function] sequence index) element element zero-based) first(seq) element(seq, 0) seq[0] element first-setter new-value sequence new-value [Function] second-setter new-value sequence ) new-value [Function] third-setter new-value sequence new-value [Function] sequence element-setter )0 new-value element first-setter(val, seq) element- setter (val, seq, 0) seq[0] := val sequence default value [Generic Function] sequence default default # last (#("emperor", "of", "china")) "china" last-setter new-value mutable-sequence new-value [Generic Function] mutable-sequence )T new-value )T new-value mutable- sequence mutable- sequence (define variable my-list = list (1, 2, 3) my-list #(1, 2, 3) last (my-list) := 4 Courier my-list #(1, 2, 4) *define variable my-empty-vector = vector() my-empty-vector last (my-empty -vector) := 4 subsequence-position Palatino big pattern test count Symbol index [Generic Function] pattern pattern pattern count count 6 subsequence-position ("Ralph Waldo Emerson", "Waldo") sequence sequence boolean [G.F. Method] sequence sequence key-test sequence => test-function [G.F. Method] key-test %(The Instantiable Collection Classes) Dylan capabilities <array> [Abstract Instantiable Class] rank) row-major) Palatino sublinear) Courier <array> dimensions: fill: dimensions: fill: <array> element element-setter <byte-string> [Sealed Instantiable Class] <vector> <string> <byte-string> size: fill: size: <byte-string> fill: <deque> [Instantiable Class] <mutable-sequence> <deque> size: fill: size: <deque> fill: <list> [Sealed Instantiable Class] <sequence> <list> size: fill: size: <list> fill: <empty-list> [Sealed Instantiable Class] <empty-list> <empty-list> <list> <empty-list> singleton(#()) object-class (#()) <empty-list> *define method f (x :: <empty-list>) 1 end; !define method f (x == #()) 2 end; $define method f (x :: <list>) 3 end; f (#()) f (#("chocolate", "vanilla")) <range> [Instantiable Class] arithmetic sequences) <sequence> Palatino (ranges) Courier from:, to:, above:, below:, by:, size: from: size: range: above: below: above: below: above: below: <simple-object-vector> [Sealed Instantiable Class] <vector> <simple-object-vector> size: fill: size: <simple- object-vector> fill: <stretchy-vector> [Abstract Instantiable Class] <vector> <stretchy-vector> size: fill: size: <stretchy-vector> fill: ring> [Abstract Instantiable Class] <sequence> <string> <string> <string> <string> <string> size: fill: size: <table> [Abstract Instantiable Class] hashtable) unstable) <table> size: <table> table-protocol Iteration Protocol) <table> table- protocol (The Table Protocol) <table> <table> Courier <object-table> <object-table> Palatino [Sealed Instantiable Class] <table> <unicode-string> [Sealed Instantiable Class] <vector> <string> <unicode-string> size: fill: size: <unicode-string> fill: <vector> [Abstract Instantiable Class] <array> vectors) <vector> <vector> <simple-object-vector> <vector> <array> (Operations on Arrays) dimensions array Symbol sequence [Function] array <array> % dimensions (make (<array>, dimension s: #(4, 4))) #(4, 4) array [G. F. Method] <array> reduce(\*, 1, dimensions( array row-major-index aref-setter dimension array [Generic Function] array Courier Palatino array Symbol [G. F. Method] array dimensions <array> row-major-index array #rest subscripts index [Generic Function] subscripts row-major) array subscripts) row-major-index array #rest subscripts index [G. F. Method] array dimensions <array> array #rest indices element [Generic Function] indices array indices indices array #rest indices element [G. F. Method] array indices row-major-index array aref-setter new-value array #rest indices new-value [Generic Function] indices array new value) indices array indices array array aref-setter new-value array #rest indices new-value [G. F. Method] array indices row-major-index element-setter <array> dimension array axis dimension [Generic Function] array array array Courier dimension Palatino array axis Symbol dimension [G. F. Method] array dimensions element <array> dimensions dimension Deques (Operations on Deques) deque new-value deque [Generic Function] )$ new-value deque deque first-element [Generic Function] deque push-last deque new-value deque [Generic Function] push-last new-value deque pop-last deque last-element [Generic Function] pop-last deque deque new-value deque [G.F. Method] deque deque remove! deque value test count deque [G.F. Method] deque remove! deque deque (Operations on Lists) <list> <pair> <empty-list> <list> <pair> <empty-list> <list> (improper list) <type-error> Palatino Courier head tail Symbol [Function] (head) (tail) pair (1, 2) #(1 . 2) pair (1, #(2, 3, 4, 5)) #(1, 2, 3, 4, 5) #rest args [Function] list (1, 2, 3) #(1, 2, 3) list (4 + 3, 4 - 3) #(7, 1) list object [Function] head (#(4, 5, 6)) head (#()) list object [Function] tail (#(4, 5, 6)) #(5, 6) tail (#()) head-setter object pair object [Function] object object # define variable x = list (4, 5, 6) #(4, 5, 6) head (x) := 9 #(9, 5, 6) tail-setter object pair object [Function] Palatino object object Courier # define variable x = list (4, 5, 6) #(4, 5, 6) tail (x) := #(9, 8, 7) #(9, 8, 7) #(4, 9, 8, 7) list element Symbol [G.F. Method] element ,list list remove! list element test count [G.F. Method] remove! list {integer [G.F. Method] boolean [G.F. Method] (final tails) list sequence boolean [G.F. Method] sequence boolean [G.F. Method] (dotted list) (Operations on Ranges) range from to above below by size range [Function] (range) above , below above below above below <range> member? val range boolean [G.F. Method] Palatino range Courier range Symbol [G.F. Method] copy-sequence range start end new-range [G.F. Method] copy-sequence class-for-copy <list> range1 range2 boolean [G.F. Method] reverse )1 range new-range [G.F. Method] reverse! )8 range range [G.F. Method] reverse! range intersection range1 range2 range [G.F. Method] intersection class-for-copy <range> range1 range2 (Operations on Stretchy Vectors) stretchy-vector new-element stretchy-vector [G.F. Method] new-element stretchy-vector stretchy-vector stretchy-vector remove! stretchy-vector element test count stretchy-vector [G.F. Method] remove! stretchy-vector stretchy-vector Palatino (Operations on Strings) Courier string1 string2 Symbol boolean [G.F. Method] strict prefix) as-lowercase string new-string [G.F. Method] map(as-lowercase, string define variable x = "Van Gogh" as-lowercase (x) "van gogh" as-lowercase! string string [G.F. Method] map-into( string , as-lowercase, string define variable x = "Van Gogh" as-lowercase! (x) "van gogh" as-uppercase string new-string [G.F. M ethod] as-uppercase, string define variable x = "Van Gogh" as-uppercase (x) "VAN GOGH" as-uppercase! string string [G.F. Method] map-into( string , as-uppercase string define variable x = "Van Gogh" as-uppercase (x) "VAN GOGH" Courier element Palatino unicode-string index #key default Symbol character [G. F. Method] <unicode-string> element element-setter character unicode-string index character [G. F. Method] <unicode-string> element-setter element byte-string index #key default character [G. F. Method] <byte-string> element element-set character byte-string index character [G. F. Method] <byte-string> element-setter (Operations on Tables) <table> <table> table-protocol <table> table-protocol (The Table Protocol) remove-key! table key table [Generic Function] remove-key! table test element-setter new-value table key [G. F. Method] element-setter (Operations on Vectors) vector #rest args vector [Function] Courier dimensions Palatino vector Symbol sequence [G. F. Method] element simple-object-vector index #key default element [G. F. Method] <simple-object-vector> element element-setter new-element simple-object-vector index [G. F. Method] new-element <simple-object-vector> element-setter (The Iteration Protocol) iteration protocol) state object) mutable collection) forward-iteration-protocol collection [Generic Function] initial-state :: <object> limit :: <object> -state :: <function> finished-state? :: <function> current-key :: <function> current-element :: <function> current-element-setter :: <function> copy-state :: <function> collection collection collection next-state copy-state Courier initial-state Palatino state limit )$ finished- state? limit initial-state limit finished-state? next-state collection state new-state collection next-state state next-state copy- state finished-state? collection state limit boolean next-state current-element current-key current-element-setter current-key collection state collection state current-key state current-element collection state element state collection current-element-setter value collection state value state collection value value <mutable-collection> copy-state collection state new-state collection state backward-iteration-protocol collection [Generic Function] Symbol final-state :: <object> limit :: <object> Courier previous-state :: <function> finished-state? :: <function> current-key :: <function> current-element :: <function> current-element-setter :: <function> copy-state :: <function> backward- iteration-protocol final- state g previous- state forward-iteration- protocol 06define method do1 (f :: <function>, c :: <collection>) , let (init, limit, next, end?, key, elt) = 3 forward-iteration-protocol(c); ( for (state = init then next(c, state), until end?(c, state, limit)) f(elt(c, state)); end for; end method do1; Palatino (The Table Protocol) complex) (equivalence predicate) X, Y, Z (1) F(X,X) F(X,Y) F(Y,X) (3) F(X,Y) F(Y,Z) F(X,Z) (equivalence class) (potential objects) equivalence class class" define class Dylan (visibly modified) Palatino test function) (hash function) hash codes) hash id) hash state) Dylan Dylan Courier table-protocol table [Generic Function] Symbol test-function hash-function <table> table-protocol <table> table-protocol table-protocol test-function key1 key2 boolean test-function hash-function state Courier hash-function Palatino state <table> <table> table-protocol object-table [G. F. Method] Symbol test-function hash-function <object-table> test-function hash-function object-hash 06define method table-protocol (table :: <object-table>) B => test-function :: <function>, hash-function :: <function>; values(\==, object-hash); end method table-protocol; merge-hash-codes id1 state1 id2 state2 ordered [Function] merged-id merged-state merged-id state1 state2 merged-state ordered ordered $permanent-hash-state [Constant] object-hash object id state [Function] component) object-hash state Palatino &Iteration Stability and Natural Order) (stable under iteration) unstable under iteration) (Collection Keys) Dylan Courier element element collection key default Symbol element [Generic Fun ction] element collection element default default element key-sequence collection [Generic Function] key-sequence collection collection collection key-sequence collection collection Courier <collection> <collection> <explicit-key-collection> <sequence> Palatino <explicit-key-collection> [Abstract Class] <explicit-key-collection> <sequence> [Abstract Class] <sequence> <collection> explicit-key-collection <sequence> <explicit-key-collection> <explicit-key-collection> forward-iteration- protocol current-key <sequence> -define method do-with-keys (f :: <function>, ; c :: <explicit-key-collection>) , let (init, limit, next, end?, key, elt) = - forward-iteration-protocol(c); ( for (state = init then next(c, state), until end?(c, state, limit)) 0% f(key(c, state), elt(c, state)); end for; end method do-with-keys; =define method do-with-keys (f :: <function>, c :: <sequence>) , let (init, limit, next, end?, key, elt) = . forward-iteration-protocol(c); for (key :: <integer> from 0, % state = init then next(c, state), until end?(c, state, limit)) f(key, elt(c, state)); end for; end method do-with-keys; Mutability) Courier <mutable-collection> <stretchy-collection> Palatino mixin classes) <mutable-collection> [Abstract Class] <collection> element-setter <stretchy-collection> [Abstract Class] <collection> element-setter ) new-value mutable-collection key [Generic Function] Symbol new-value new-value mutable- collection collection element-setter new-value element-setter <stretchy-collection> element-setter <explicit-key-collection> <sequence> size- setter key + 1 <mutable-collection> <sequence> <explicit-key- colle ction> <mutable-sequence> !<mutable-explicit-key-collection> <mutable-sequence> [Abstract Class] <sequence> <mutable-collection> !<mutable-explicit-key-collection> [Abstract Class] <explicit-key-collection> <mutable-collection> Palatino (Collection Alignment) )$ (mapping) multi-collection) effectively) Courier element element-setter )x key-test key-test(c1) == key-test(c2) 08define method do2 (f :: <function>, c1 :: <collection>, & c2 :: <collection>) > let keys = intersection(key-sequence(c1), key-sequence(c2)); ) let (init, limit, next, end?, key, elt) #= forward-iteration-protocol(keys); 0+ for (state = init then next(keys, state), & until end?(keys, state, limit)) let key = elt(keys, state); f(c1[key], c2[key]); end for; end method do2; element key-sequence 0<define method do2 (f :: <function>, c1 :: <sequence>, c2 :: <sequence>) / let (init1, limit1, next1, end1?, key1, elt1) != forward-iteration-protocol(c1); 0/ let (init2, limit2, next2, end2?, key2, elt2) != forward-iteration-protocol(c2); 0- for (state1 = init1 then next1(c1, state1), Courier state2 = init2 then next2 (c2, state2), 0* until (end1?(c1, state1, limit1) | ) end2?(c2, state2, limit2))) * f(elt1(c1, state1), elt2(c2, state2)); end for; end method do2; Palatino map-into 08define method map-into1 (target :: <mutable-collection>, ) f :: <function>, 0 source :: <collection>) 0 let keys = intersection(key-sequence(target), 0 key-sequence(source)); ) let (init, limit, next, end?, key, elt) !forward-iteration-protocol(keys); 0+ for (state = init then next(keys, state), & until end?(keys, state, limit)) let key = elt(keys, state); " target[key] := f(source[key]); end for; end method map-into1; 6define method map-into1 (target :: <mutable-sequence>, f :: <function>, source :: <sequence>) 07 let (init1, limit1, next1, end1?, key1, elt1, setter) %= forward-iteration-protocol(target); 0/ let (init2, limit2, next2, end2?, key2, elt2) %= forward-iteration-protocol(source); 01 for (state1 = init1 then next1(target, state1), 1 state2 = init2 then next2(source, state2), - until (end1?(target, state1, limit1) | - end2?(source, state2, limit2))) 3 setter(target, state1, f(elt2(source, state2))) end for; end method map-into1; ,(Defining a New Collection Class: A Summary) forward-iteration-protocol backward element key-test <mutable-collection> element-setter Courier <mutable-collection> class-for-copy <table> table-protocol Palatino member? reverse! sort! Palatino (Characters and Symbols) (Characters) Courier <character> [Instantiable Class] <character> <object> as-uppercase ) character Symbol uppercase-character [G.F. Method] as-uppercase <character> )l character )0 character as-lowercase ) character lowercase-character [G.F. Method] as-lowercase <character> )< character )0 character ) <integer> character integer [G.F. Method] )l character <character> integer character [G.F. Method] integer integer )N (Symbols) <symbol> as(<symbol>, string as(<string>, symbol Palatino Courier example: == #"Example" as(<string>, symbol <symbol> [Class] <symbol> <object> <symbol> string Symbol symbol [G.F. Method] string as (<symbol>, "foo") #"foo" #"FOO" == as (<symbol>, "Foo") #"Foo" #"foo" ) <string> symbol string [G.F. Method] as (<string>, #"Foo") "Foo" Palatino (Numbers) Dylan Helvetica <number> l <complex> <real> <rational> <integer> <ratio> <float> <single-float> <double-float> <extended-float> ABSTRACT INSTANTIABLE SEALED NUMBER CLASSES Courier <single-float> <double-float> <extended-float> (Automatic Type Conversion) Dylan Common Lisp (X3J13) rational canonicalization) (coercions) (Numeric Classes) <number> [Abstract Class] <real> [Sealed Class] <float> [Sealed Class] <single-float> [Sealed Class] <double-float> [Sealed Class] <extended-float> [Sealed Class] <rational> [Sealed Class] Courier <ratio> Palatino [Sealed Class] <integer> [Sealed Class] <complex> [Sealed Class] (General Arithmetic Functions) (Properties) integer Symbol boolean [Generic Function] even? integer boolean [Generic Function] zero? )# number boolean [Generic Function] positive? real boolean [Generic Function] negative? real boolean [Generic Function] integral? )? number boolean [Generic Function] (Arithmetic Operations) number1 number2 number [Generic Function] number1 number2 number [Generic Function] number1 number2 number [Generic Function] number1 number2 number [Generic Function] +, *, -, / 0 5 + 6 * 4 \+, \*, \- 0.define class <my-number> (<number>) end class; 5define method \+ (a :: <my-number>, b :: <my-number>) $ my-personal-addition-method(a, b); end method; negative number number [Generic Function] Courier negative floor Palatino Symbol integer real [Generic Function] ceiling integer real [Generic Function] round integer real [Generic Function] truncate integer real [Generic Function] Common Lisp (X3J13) floor/ real1 real2 integer real [Generic Function] ceiling/ real1 real2 integer real [Generic Function] round/ real1 real2 nteger real [Generic Function] truncate real1 real2 integer real [Generic Function] Common Lisp (X3J13) floor ceiling round truncate modulo real1 real2 real [Generic Function] modulo floor/ ( real1 real2 remainder real1 real2 real [Generic Function] remainder truncate/ ( real1 real2 number1 integer2 number [Generic Function] number1 integer2 number number [Generic Function] logior #rest integers integer [Generic Function] logxor #rest integers integer [Generic Function] logand #rest integers integer [Generic Function] lognot integer integer [Generic Function] logbit? index integer boolean [Generic Function] integer count integer [Generic Function] logior logxor logand lognot Common Lisp logbit? Common Lisp logbitp Courier rationalize Palatino number Symbol number [Generic Function] numerator number number [Generic Function] denominator number number [Generic Function] rationalize numerator denominator Revised Report on Scheme integer1 integer2 integer [Generic Function] integer1 integer2 integer [Generic Function] integer1 integer2 real #rest more-reals real [Function] #rest more-reals [Function] Palatino (Other Operations) (Functional Operations) Dylan Courier compose function1 #rest more-functions Symbol function [Function] compose compose compose compose /define method square (x :: <number>) x * x end; square 0define method square-all (coords :: <sequence>) map (square, coords); end; square-all )define method sum (numbers :: <sequence>) reduce1 (\+, numbers); end; 1define constant distance = compose(sqrt, sum, squ b are-all); distance distance ( #(3, 4, 5) ); 7.0710678118654755 complement ) predicate function [Function] complement predicate predicate complement complement complement (even?) 1map (female?, list (michelle, arnold, roseanne)); #(#t, #f, #t) >map (complement (female?), list (michelle, arnold, roseanne)); #(#f, #t, #f) disjoin predicate1 #rest more-predicates function [Function] disjoin disjunction) Palatino Courier conjoin predicate1 #rest more-predicates Symbol function [Function] conjoin conjunction) curry ) function #rest curried-args new-function [Function] curry curried-args function curry (\=, "x") curry (\+, 1) curry (\>, curry (concatenate, "set-") "set-" ap (curry (\+, 1), #(3, 4, 5)) #(4, 5, 6) rcurry function #rest curried-args new-function [Function] rcurry (right curry function curry rcurry (\>, 6) : define constant yuppify = rcurry (concatenate, ", ayup"); yuppify " yuppify ("I'm from New Hampsha"); "I'm from New Hampsha, ayup" always object function [Function] always object always (1) ("x", "y", "z") always (#t) (#f, #f) Palatino (Function application) Courier apply function #rest Symbol values [Function] apply function function apply(\+, #(1, 2)) 1 + 2 define co )<.nstant math-functions = list (\+, \*, \/, \-)) math-functions 04#({generic +}, {generic *}, {generic /}, {generic }) first (math-functions) {generic +} ( apply (first (math-functions), #(1, 2)) Identity function) identity object object [Function] identity object Palatino (Conditions) Background) Common Lisp, C++, PL/I, Ada (informal) overall structure) (raise throw (on-unit catch signalers) Palatino Common Lisp Common Lisp unwound) Common Lisp mmon Lisp Common Lisp ad hoc) Common Lisp Common Lisp Palatino Ada, PL/I Multics Common Courier unwind-protect Dylan Common Lisp Common Lisp unwind-protect Dylan block cleanup clause) Common Lisp Guy L. Steele Jr Common Lisp: the Language ANSI C++ Margaret A. Ellis Bjarne Stroustrup "The Annotated C++ Reference Manual Dylan condition system) (Overview) Dylan M(signal) next-ha ndler (outside stack) uCommon Lisp Palatino signaling unit) middle stack) inside stack) Courier block exception restarting) signal signal signal component) handling by returning) { recovery protocol) (handling by termina ting) Palatino Courier <unbound-slot> <new-value> <new-value> value: permanent: Introspective functions) serious condition) (intervene) (Specification) Dylan (Format Strings) format directives) Courier Palatino )H <integer> )T <integer> )T <integer> )T <integer> <character> <string> <condition> <object> Common Lisp format printf streams library) <simple-error>, mple-restart> <simple-warning> )- (Classes) Dylan Dylan <condition> <condition> <serious-condition> <error> <simple-error> <type-error> <simple-warning> <simple-restart> <abort> ABSTRACT INSTANTIABLE CONDITION CLASSES +*3 <warning> )l <restart> Courier <condition> Palatino [Abstract Class] <condition> indefinite extent) <condition> <serious-condition> [Abstract Class] <serious-condition> <serious-condition> <error> [Abstract Class] <error> <error> <serious- condition> <error> <serious-condition> trap) <simple-error> [Instantiable Class] <simple-error> <error> format- string: format-arguments: condition- format-string condition-format-arguments <type-error> [Instantiable Class] <type-error> check-type <error> value: type: type-error-value type-error-expected-type Courier <sealed-object-error> Palatino [Instantiable Class] <sealed-object-error> <error> <warning> [AbstractClass] <warning> <condition> <warning> <simple-warning> [Instantiable Class] <simple-warning> signal )H <warning> <warning> <simple-error> <restart> [Abstract Class] )< <restart> <restart> <condition> <restart> , <restart> condition: <simple-restart> [Instantiable Class] <simple-restart> cerror )< <restart> format-string: format-arguments: condition-format-string condition-format-arguments <abort> [Instantiable Class] <abort> <restart> <abort> (Basic Operator for Signaling) signal ) condition Symbol values [Function] Palatino condition Courier signal default-handler( )p condition signal condition signal signal condition signal ((Basic Operator for Handling Conditions) let handler condition handler [Local Declaration] let handler dynamic extent) condition test: ] [, init-arguments: init-arguments handler init-arguments let handler type <set- and-continue> <unbound-slot> handler next handler signal next-handler Palatino init-arguments type handler condition wall) handler Courier let handler let handler (Miscellaneous Condit ion Operations) $Full Set of Operators for Signaling) primitives) signal ) condition Symbol values [Function] signal string argument argument values condition signal default-handler( )p condition signal condition signal signal )$ condition signal Courier <simple-warning> error Palatino condition Symbol [Function] error string argument argument error signal error bombs) error <simple-error> cerror restart-description condition [Function] cerror ) #restart-description string argument argument cerror error init-arguments: format- string: restart-description format-arguments: argument argument , ... <simple-re start> cerror cerror cerror cerror break condition [Function] break string argument argument break signal break <simple-restart> break check-type value type value [Function] instance?( value , type check-type <type-error> abort [Function] error(make (<abort>)) abort signal error Palatino #(Additional Operators for Handling) Dylan Courier block )? exception block body cleanup-clauses block exception-clauses exception ( | #key test init-arguments exception-body exception-body exception-body exception-body block cleanup-clauses exception-body init-arguments let handler block body block (return) open-files(); ... result exception (<error>) return(#f); cleanup close-files(); end block default-handler ) condition Symbol values [Generic Function] default-handler <condition> <serious-condition> <warning> )0 <restart> #Operators for Interactive Handling) restart-query [Generic Function] restart-query restart Palatino making a restart) Courier restart-query <restart> return-query ) condition [Generic Function] condition return-allowed? return-query return-query Operators for Introspection) do-handlers funarg [Function] do-handlers funarg funarg function init-arguments init-arguments return-allowed? ) condition Symbol boolean [Generic Function] )H condition <condition> return-allowed? return-description ) condition description [Generic Function] return- description description) description return-allowed? return-description return-description Palatino (Modules) ` segments) (Module variables) Dylan (Overview) owned) using) import) export) accessible) Courier define module create Dylan define constant define variable define generic define class define method define class object-class Palatino /Programs, module declarations, and expressions) Dylan Courier begin define module (Module declarations) define module define module module-name [Definition] module-clauses end [ module ] [ module-name module-clause (use clause) create clause) Palatino export clause) module-name module-name (Used modules) use-clause use-clause Courier module-name module-use-options module-name module-use-options module-use-option import-option import: all import: import-set import-set imports imports import import imports Courier import variable-name variable-name variable-name Palatino import-option import: {foo => bar} #import: {foo}, rename: {foo => bar} exclude-option exclude: variable-name-set variable-name-set variable-names variable-names variable-name variable-name variable-names import: exclude: prefix-option prefix: string string rename: prefix: rename-option $ rename: { rename-specs rename-specs rename-spec rename-spec rename-specs rename-spec $ old-name new-name import: exclude: prefix: import: export: D old-name new-name prefix: rename rename: Courier export-option export: all export: variable-name-set Palatino variable-name variable-name export: Exporting owned variables) (module export clause) export variable-names variable-name module create clause) create variable-names variable-name Examples define module graphics use dylan; create draw-line, erase-line, invert-line, skew-line frame-rect, fill-rect, Courier erase-rect, invert-rect; end module graphics; define module lines use dylan; use graphics, import: {draw-line, erase-line, invert-line, skew-line}; end module lines; define module rectangles use dylan; use graphics, prefix: "graphics$", exclude: {skew-line}; end module rectangles; define module dylan-gx use dylan, export: all; use graphics, !rename: {skew-line => warp-line}, export: all; end module dylan-gx; graphics )H draw-line erase-line invert-line skew-line frame-rect fill-rect erase-rect invert-rect Dylan Palatino )# module lines )H draw-line erase-line invert-line skew-line Dylan )# module rectangles graphics$draw-line graphics$erase-line graphics$invert-line graphics$frame-rect graphics$fill-rect graphics$erase-rect Courier graphics$invert-rect Dylan Palatino )# module dylan-gx )H draw-line erase-line invert-line warp-line frame-rect fill-rect erase-rect invert-rect Dylan )# module lines rectangles graphics graphics dylan-gx dylan-gx dylan graphics Palatino (Libraries) Dylan Courier module library library-export-clause library-export-clause module-name library-use-option export: all export-option Palatino library-use-clause use-clau use-clause use-clause use-clauses library-use-clause module-use-clause library-use-clause library-name Courier dylan dylan Dylan Dylan dylan begin define library dylan-user Palatino Dylan B9%+GE< @R@7 `/ 9 2F945 p 0p`P 6:@75* "A>/+ F 9@ 8$0* %X`PD@ 8 (00 8 8 0 %+&*)1: 9><CA 2!#6G=H PP0P r`gPA '$`C6 `N \P@ ?a q B9%+GE< 2F945 6:@75* "A>/+ %+&*)1: 9><CA 2!#6G=H Macintosh 32-bit temp.0001 BKMacRecorder BfMacintosh IIfx mutsumi Mutchan EOFST ffffff ffff33 ff33ff ff3333 33ffff 33ff33 3333ff 333333 wwwwww UUUUUU DDDDDD """""" Palatino Helvetica Courier Symbol9 l/bpl/bp l/bpl/bp l/bpl/bp l/bpl/bp jPREC vPRVS | Chap.8-15 CGDCCGVM CGDCCGVM